home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / FPSE_src / gte.c < prev    next >
C/C++ Source or Header  |  2000-01-01  |  25KB  |  1,032 lines
  1. /* gte.c */
  2. /*
  3.      1999 by BERO
  4.  
  5.      modified by LDChen
  6.  
  7.      document from:
  8.  
  9.      http://psx.rules.org
  10.      doomed@c64.org
  11.  
  12.      not tested BIG_ENDIAN
  13. */
  14.  
  15. #include "fpse.h"
  16.  
  17. typedef INT16 MATRIX[10];
  18.  
  19. typedef struct {
  20.     INT32 x,y,z;
  21. } LVECTOR;
  22.  
  23. typedef union {
  24.     INT32   LongW;
  25.     struct {
  26. #ifndef MSB_FIRST
  27.         INT16   Low,High;
  28. #else
  29.         INT16   High,Low;
  30. #endif
  31.     } ShortW;
  32. } INT16W32;
  33.  
  34. typedef union {
  35.     UINT32  LongW;
  36.     struct {
  37. #ifndef MSB_FIRST
  38.         UINT16  Low,High;
  39. #else
  40.         UINT16  High,Low;
  41. #endif
  42.     } ShortW;
  43. } UINT16W32;
  44.  
  45. #ifndef MSB_FIRST
  46.  
  47. typedef struct {
  48.     INT16 x,y,z,pad;
  49. } SVECTOR;
  50.  
  51. typedef struct {
  52.     INT16   x,y;
  53. } VECTOR2D;
  54.  
  55. typedef struct {
  56.     UINT8 r,g,b,code;
  57. } RGBcd;
  58.  
  59. #else
  60.  
  61. typedef struct {
  62.     INT16 y,x,pad,z;
  63. } SVECTOR;
  64.  
  65. typedef struct {
  66.     INT16   y,x;
  67. } VECTOR2D;
  68.  
  69. typedef struct {
  70.     UINT8 code,b,g,r;
  71. } RGBcd;
  72.  
  73. #endif /* BIG_ENDIAN */
  74.  
  75. typedef struct {
  76. /* DATA_REGS */
  77.     SVECTOR     v0;
  78.     SVECTOR     v1;
  79.     SVECTOR     v2;
  80.     RGBcd       rgb;
  81.     UINT16W32   otz;
  82.     INT16W32    ir0;
  83.     INT16W32    ir1;
  84.     INT16W32    ir2;
  85.     INT16W32    ir3;
  86.     VECTOR2D    sxy0;
  87.     VECTOR2D    sxy1;
  88.     VECTOR2D    sxy2;
  89.     VECTOR2D    sxyp;
  90.     UINT16W32   sz0;
  91.     UINT16W32   sz1;
  92.     UINT16W32   sz2;
  93.     UINT16W32   sz3;
  94.     RGBcd       rgb0;
  95.     RGBcd       rgb1;
  96.     RGBcd       rgb2;
  97.     INT32       res1;
  98.     INT32       mac0;
  99.     INT32       mac1;
  100.     INT32       mac2;
  101.     INT32       mac3;
  102.     INT32       irgb;
  103.     INT32       orgb;
  104.     INT32       lzcs;
  105.     INT32       lzcr;
  106.  
  107. /* CTRL_REGS */
  108.     MATRIX      rot;
  109.     LVECTOR     tr;
  110.     MATRIX      light;
  111.     LVECTOR     bk;
  112.     MATRIX      color;
  113.     LVECTOR     fc;
  114.     INT32       ofx,ofy;
  115.     UINT16W32   h;
  116.     INT16W32    dqa;
  117.     INT16W32    dqb;
  118.     INT16W32    zsf3;
  119.     INT16W32    zsf4;
  120.     INT32       flag;
  121. } REGS;
  122.  
  123. #define   VX0  r->v0.x
  124. #define   VY0  r->v0.y
  125. #define   VZ0  r->v0.z
  126. #define   VX1  r->v1.x
  127. #define   VY1  r->v1.y
  128. #define   VZ1  r->v1.z
  129. #define   VX2  r->v2.x
  130. #define   VY2  r->v2.y
  131. #define   VZ2  r->v2.z
  132. #define   RGB  r->rgb
  133. #define   R    (UINT32)(r->rgb.r)
  134. #define   G    (UINT32)(r->rgb.g)
  135. #define   B    (UINT32)(r->rgb.b)
  136. #define   OTZ  r->otz.LongW
  137. #define   IR0     (INT32)(r->ir0.ShortW.Low)
  138. #define   IR1     (INT32)(r->ir1.ShortW.Low)
  139. #define   IR2     (INT32)(r->ir2.ShortW.Low)
  140. #define   IR3     (INT32)(r->ir3.ShortW.Low)
  141. #define   IR0_32  (r->ir0.LongW)
  142. #define   IR1_32  (r->ir1.LongW)
  143. #define   IR2_32  (r->ir2.LongW)
  144. #define   IR3_32  (r->ir3.LongW)
  145. #define   SX0  r->sxy0.x
  146. #define   SY0  r->sxy0.y
  147. #define   SX1  r->sxy1.x
  148. #define   SY1  r->sxy1.y
  149. #define   SX2  r->sxy2.x
  150. #define   SY2  r->sxy2.y
  151. #define   SXP  r->sxyp.x
  152. #define   SYP  r->sxyp.y
  153. #define   SXY0 r->sxy0
  154. #define   SXY1 r->sxy1
  155. #define   SXY2 r->sxy2
  156. #define   SZ0  (UINT32)(r->sz0.ShortW.Low)
  157. #define   SZ1  (UINT32)(r->sz1.ShortW.Low)
  158. #define   SZ2  (UINT32)(r->sz2.ShortW.Low)
  159. #define   SZ3  (UINT32)(r->sz3.ShortW.Low)
  160. #define   SZ0_32  r->sz0.LongW
  161. #define   SZ1_32  r->sz1.LongW
  162. #define   SZ2_32  r->sz2.LongW
  163. #define   SZ3_32  r->sz3.LongW
  164.  
  165. #define   RGB0 r->rgb0
  166. #define   RGB1 r->rgb1
  167. #define   RGB2 r->rgb2
  168. #define   MAC0 r->mac0
  169. #define   MAC1 r->mac1
  170. #define   MAC2 r->mac2
  171. #define   MAC3 r->mac3
  172. #define   IRGB r->irgb
  173. #define   ORGB r->orgb
  174. #define   LZCS r->lzcs
  175. #define   LZCR r->lzcr
  176.  
  177. #ifndef MSB_FIRST
  178. #define   _11  0
  179. #define   _12  1
  180. #define   _13  2
  181. #define   _21  3
  182. #define   _22  4
  183. #define   _23  5
  184. #define   _31  6
  185. #define   _32  7
  186. #define   _33  8
  187. #else
  188. #define   _11  1
  189. #define   _12  0
  190. #define   _13  3
  191. #define   _21  2
  192. #define   _22  5
  193. #define   _23  4
  194. #define   _31  7
  195. #define   _32  6
  196. #define   _33  9
  197. #endif
  198.  
  199. #define   R11  r->rot[_11]
  200. #define   R12  r->rot[_12]
  201. #define   R13  r->rot[_13]
  202. #define   R21  r->rot[_21]
  203. #define   R22  r->rot[_22]
  204. #define   R23  r->rot[_23]
  205. #define   R31  r->rot[_31]
  206. #define   R32  r->rot[_32]
  207. #define   R33  r->rot[_33]
  208. #define   TRX  r->tr.x
  209. #define   TRY  r->tr.y
  210. #define   TRZ  r->tr.z
  211. #define   L11  r->light[_11]
  212. #define   L12  r->light[_12]
  213. #define   L13  r->light[_13]
  214. #define   L21  r->light[_21]
  215. #define   L22  r->light[_22]
  216. #define   L23  r->light[_23]
  217. #define   L31  r->light[_31]
  218. #define   L32  r->light[_32]
  219. #define   L33  r->light[_33]
  220. #define   RBK  r->bk.x
  221. #define   GBK  r->bk.y
  222. #define   BBK  r->bk.z
  223. #define   LR1  r->color[_11]
  224. #define   LR2  r->color[_12]
  225. #define   LR3  r->color[_13]
  226. #define   LG1  r->color[_21]
  227. #define   LG2  r->color[_22]
  228. #define   LG3  r->color[_23]
  229. #define   LB1  r->color[_31]
  230. #define   LB2  r->color[_32]
  231. #define   LB3  r->color[_33]
  232. #define   RFC  r->fc.x
  233. #define   GFC  r->fc.y
  234. #define   BFC  r->fc.z
  235. #define   OFX  (r->ofx>>16)
  236. #define   OFY  (r->ofy>>16)
  237. #define   H    (UINT32)(r->h.ShortW.Low)
  238. #define   DQA  (INT32)(r->dqa.ShortW.Low)
  239. #define   DQB  (INT32)(r->dqb.LongW)
  240. #define   ZSF3 (INT32)(r->zsf3.ShortW.Low)
  241. #define   ZSF4 (INT32)(r->zsf4.ShortW.Low)
  242. #define   FLAG r->flag
  243.  
  244. #define   CODE r->rgb.code
  245. #define   R0   r->rgb0.r
  246. #define   G0   r->rgb0.g
  247. #define   B0   r->rgb0.b
  248. #define   R2   r->rgb2.r
  249. #define   G2   r->rgb2.g
  250. #define   B2   r->rgb2.b
  251. #define   CD2  r->rgb2.code
  252.  
  253. #define   FIX(a)    ((a)>>12)
  254. #define CFIX(a) ((a)/256.0)
  255.  
  256. #define LOWLM(a)    (((a) < 0) ? 0 : (a))
  257.  
  258. #define   LIMIT(a,min,max)    if (a<min) a=min; else if (a>max) a=max
  259. /* (a<min)?min:(a>max)?max:a */
  260.  
  261. #define   DEFFUNC(func)  static void func(REGS *r)
  262.  
  263. #ifdef __GNUC__
  264. /* GCC specific */
  265. #define LIM0(a,max,bit)       \
  266.      ({INT32 t=(INT32)(a);         \
  267.      if ((UINT32)(t)>max) {        \
  268.           FLAG |= (1<<bit);   \
  269.           t = ~(t >> 0x1F);   \
  270.      } t &= max; t; })
  271.  
  272. #define   LIM(a,min,max,bit) \
  273.      ({int t=a; \
  274.      if (t<min) {t=min;FLAG|=1<<bit; } \
  275.      else if (t>max) {t=max;FLAG|=1<<bit; } \
  276.      else {} t; })
  277. /* endif gcc specific */
  278. #else
  279. #define   LIM(a,min,max,bit) \
  280.      ( ((a)<min) ? (FLAG|=(1<<bit),min) : \
  281.      ( ((a)>max) ? (FLAG|=(1<<bit),max) : (/*FLAG&=~(1<<bit),*/(a)) ) )
  282. #endif
  283.  
  284. /* A1,A2,A3,F needs 64bit calculate, so ignore */
  285. #define   Lm_B1(a)  LIM(a,-32768,32767,24)
  286. #define   Lm_B2(a)  LIM(a,-32768,32767,23)
  287. #define   Lm_B3(a)  LIM(a,-32768,32767,22)
  288.  
  289. #define   Lm1_B1(a) LIM0(a,0x7FFF,24)
  290. #define   Lm1_B2(a) LIM0(a,0x7FFF,23)
  291. #define   Lm1_B3(a) LIM0(a,0x7FFF,22)
  292.  
  293. #define   Lm_C1(a)  LIM0(a,0xFF,21)
  294. #define   Lm_C2(a)  LIM0(a,0xFF,20)
  295. #define   Lm_C3(a)  LIM0(a,0xFF,19)
  296. #define   Lm_D(a)        LIM0(a,0xFFFF,18)
  297. #define   Lm_G1(a)  LIM(a,-1024,1023,14)
  298. #define   Lm_G2(a)  LIM(a,-1024,1023,13)
  299. #define   Lm_H(a)        LIM0(a,0xFFF,12)
  300.  
  301. #define   MAC2RGB() \
  302.      RGB0 = RGB1; RGB1 = RGB2; \
  303.      R2 = Lm_C1(MAC1); \
  304.      G2 = Lm_C2(MAC2); \
  305.      B2 = Lm_C3(MAC3); \
  306.      CD2 = CODE
  307.  
  308. #define   MAC2RGBx(nshift)            \
  309.      RGB0 = RGB1; RGB1 = RGB2;   \
  310.      R2 = Lm_C1(MAC1 >> nshift); \
  311.      G2 = Lm_C2(MAC2 >> nshift); \
  312.      B2 = Lm_C3(MAC3 >> nshift); \
  313.      CD2 = CODE
  314.  
  315. #define   MAC2IR()  \
  316.      IR1_32 = Lm_B1(MAC1); \
  317.      IR2_32 = Lm_B2(MAC2); \
  318.      IR3_32 = Lm_B3(MAC3)
  319.  
  320. #define   MAC2IR1() \
  321.      IR1_32 = Lm1_B1(MAC1); \
  322.      IR2_32 = Lm1_B2(MAC2); \
  323.      IR3_32 = Lm1_B3(MAC3)
  324.  
  325. #define MAC2SZ(a,z,h2,zz)                    \
  326.      {    INT32 t=a;                    \
  327.           if ((UINT32)(t) > 0xFFFF) {        \
  328.                FLAG |= (1<<18);         \
  329.                t = ~(t >> 0x1F);        \
  330.           }                        \
  331.           t &= 0xFFFF; z = zz = t;      \
  332.           if (t < h2) {                 \
  333.                if (t<1) FLAG |= (1<<18);     \
  334.                z = h2; FLAG |= (1<<17); \
  335.           }                        \
  336.      }
  337.  
  338. #define I2F(a)      (double)(a)
  339. #define F2I(a)      (INT32)(a)
  340.  
  341. #define   F_R11     I2F(R11)
  342. #define   F_R12     I2F(R12)
  343. #define   F_R13     I2F(R13)
  344. #define   F_R21     I2F(R21)
  345. #define   F_R22     I2F(R22)
  346. #define   F_R23     I2F(R23)
  347. #define   F_R31     I2F(R31)
  348. #define   F_R32     I2F(R32)
  349. #define   F_R33     I2F(R33)
  350.  
  351. #define   F_L11     I2F(L11)
  352. #define   F_L12     I2F(L12)
  353. #define   F_L13     I2F(L13)
  354. #define   F_L21     I2F(L21)
  355. #define   F_L22     I2F(L22)
  356. #define   F_L23     I2F(L23)
  357. #define   F_L31     I2F(L31)
  358. #define   F_L32     I2F(L32)
  359. #define   F_L33     I2F(L33)
  360.  
  361. #define   F_LR1     I2F(LR1)
  362. #define   F_LR2     I2F(LR2)
  363. #define   F_LR3     I2F(LR3)
  364. #define   F_LG1     I2F(LG1)
  365. #define   F_LG2     I2F(LG2)
  366. #define   F_LG3     I2F(LG3)
  367. #define   F_LB1     I2F(LB1)
  368. #define   F_LB2     I2F(LB2)
  369. #define   F_LB3     I2F(LB3)
  370.  
  371. #define   F_VX0     I2F(VX0)
  372. #define   F_VY0     I2F(VY0)
  373. #define   F_VZ0     I2F(VZ0)
  374. #define   F_VX1     I2F(VX1)
  375. #define   F_VY1     I2F(VY1)
  376. #define   F_VZ1     I2F(VZ1)
  377. #define   F_VX2     I2F(VX2)
  378. #define   F_VY2     I2F(VY2)
  379. #define   F_VZ2     I2F(VZ2)
  380.  
  381. #define F_DQA       I2F(DQA << 16)
  382. #define F_DQB       I2F(DQB)
  383. #define F_H         I2F(H)
  384. #define F_FIX(a)    (double)((a) / 4096.0)
  385. #define F2I_FIX(a)  (INT32)(F_FIX(a))
  386.  
  387.  
  388. #define DEPTH  f_rz = F_DQB + F_DQA*f_rz;    \
  389.           MAC0 = F2I(f_rz);        \
  390.           IR0_32 = Lm_H(F2I_FIX(f_rz))
  391.  
  392. DEFFUNC(RTPS)
  393. {
  394.      /* RTPS */
  395.      int z,rz;
  396.      double f_rz;
  397.  
  398.      FLAG = 0;
  399.      SZ0_32 = SZ1; SZ1_32=SZ2; SZ2_32=SZ3;
  400.      SXY0 = SXY1; SXY1=SXY2;
  401.      MAC1 = F2I_FIX(F_R11*F_VX0 + F_R12*F_VY0 + F_R13*F_VZ0)+TRX;
  402.      MAC2 = F2I_FIX(F_R21*F_VX0 + F_R22*F_VY0 + F_R23*F_VZ0)+TRY;
  403.      MAC3 = F2I_FIX(F_R31*F_VX0 + F_R32*F_VY0 + F_R33*F_VZ0)+TRZ;
  404.      MAC2IR();
  405.      rz = H >> 1;
  406.      MAC2SZ(MAC3,z,rz,SZ3_32);
  407.      f_rz = F_H/I2F(z);
  408.      SX2 = Lm_G1( F2I(I2F(MAC1)*f_rz)+OFX );
  409.      SY2 = Lm_G2( F2I(I2F(MAC2)*f_rz)+OFY );
  410.  
  411. // printf("DQB=%08x - DQA=%08x - H=%08x - Z=%08x\n",DQB,DQA,H,z);
  412.      DEPTH;
  413. }
  414.  
  415. DEFFUNC(RTPT)
  416. {
  417. // RTPT
  418.      int z,hme;
  419.      double f_rz,fx,fy,fz;
  420.  
  421.      FLAG = 0;
  422.      SZ0_32 = SZ3;
  423.      hme = H >> 1;
  424.  
  425.      fx = F_FIX(F_R11*F_VX0 + F_R12*F_VY0 + F_R13*F_VZ0)+I2F(TRX);
  426.      fy = F_FIX(F_R21*F_VX0 + F_R22*F_VY0 + F_R23*F_VZ0)+I2F(TRY);
  427.      fz = F_FIX(F_R31*F_VX0 + F_R32*F_VY0 + F_R33*F_VZ0)+I2F(TRZ);
  428.      MAC2SZ(F2I(fz),z,hme,SZ1_32);
  429.      f_rz = F_H/I2F(z);
  430.      SX0 = Lm_G1( F2I(fx*f_rz)+OFX );
  431.      SY0 = Lm_G2( F2I(fy*f_rz)+OFY );
  432.  
  433.      fx = F_FIX(F_R11*F_VX1 + F_R12*F_VY1 + F_R13*F_VZ1)+I2F(TRX);
  434.      fy = F_FIX(F_R21*F_VX1 + F_R22*F_VY1 + F_R23*F_VZ1)+I2F(TRY);
  435.      fz = F_FIX(F_R31*F_VX1 + F_R32*F_VY1 + F_R33*F_VZ1)+I2F(TRZ);
  436.      MAC2SZ(F2I(fz),z,hme,SZ2_32);
  437.      f_rz = F_H/I2F(z);
  438.      SX1 = Lm_G1( F2I(fx*f_rz)+OFX );
  439.      SY1 = Lm_G2( F2I(fy*f_rz)+OFY );
  440.  
  441.      fx = F_FIX(F_R11*F_VX2 + F_R12*F_VY2 + F_R13*F_VZ2)+I2F(TRX);
  442.      MAC1 = F2I(fx);
  443.      fy = F_FIX(F_R21*F_VX2 + F_R22*F_VY2 + F_R23*F_VZ2)+I2F(TRY);
  444.      MAC2 = F2I(fy);
  445.      fz = F_FIX(F_R31*F_VX2 + F_R32*F_VY2 + F_R33*F_VZ2)+I2F(TRZ);
  446.      MAC3 = F2I(fz);
  447.      MAC2SZ(MAC3,z,hme,SZ3_32);
  448.      f_rz = F_H/I2F(z);
  449.      MAC2IR();
  450.      SX2 = Lm_G1( F2I(fx*f_rz)+OFX );
  451.      SY2 = Lm_G2( F2I(fy*f_rz)+OFY );
  452.  
  453.      DEPTH;
  454. }
  455.  
  456. /* MVMVA functions */
  457. #define M(a)    (double)(m[a])
  458. #define Vx      (double)(v->x)
  459. #define Vy      (double)(v->y)
  460. #define Vz      (double)(v->z)
  461. #define Cx      (INT32)(cv->x)
  462. #define Cy      (INT32)(cv->y)
  463. #define Cz      (INT32)(cv->z)
  464.  
  465. static void mvmva(REGS *r,SVECTOR *v,MATRIX m)
  466. {
  467.      MAC1 = F2I_FIX(M(_11)*Vx + M(_12)*Vy + M(_13)*Vz);
  468.      MAC2 = F2I_FIX(M(_21)*Vx + M(_22)*Vy + M(_23)*Vz);
  469.      MAC3 = F2I_FIX(M(_31)*Vx + M(_32)*Vy + M(_33)*Vz);
  470.      FLAG = 0;
  471. }
  472.  
  473. static void mvmva0(REGS *r,SVECTOR *v,MATRIX m)
  474. {
  475.      MAC1 = F2I(M(_11)*Vx + M(_12)*Vy + M(_13)*Vz);
  476.      MAC2 = F2I(M(_21)*Vx + M(_22)*Vy + M(_23)*Vz);
  477.      MAC3 = F2I(M(_31)*Vx + M(_32)*Vy + M(_33)*Vz);
  478.      FLAG = 0;
  479. }
  480.  
  481. static void mvmva_cv(REGS *r,SVECTOR *v,MATRIX m,LVECTOR *cv)
  482. {
  483.      MAC1 = F2I_FIX(M(_11)*Vx + M(_12)*Vy + M(_13)*Vz) + Cx;
  484.      MAC2 = F2I_FIX(M(_21)*Vx + M(_22)*Vy + M(_23)*Vz) + Cy;
  485.      MAC3 = F2I_FIX(M(_31)*Vx + M(_32)*Vy + M(_33)*Vz) + Cz;
  486.      FLAG = 0;
  487. }
  488.  
  489. static void mvmva_cv_ir(REGS *r,MATRIX m,LVECTOR *cv)
  490. {
  491.      MAC1 = F2I_FIX(M(_11)*IR1 + M(_12)*IR2 + M(_13)*IR3)+Cx;
  492.      MAC2 = F2I_FIX(M(_21)*IR1 + M(_22)*IR2 + M(_23)*IR3)+Cy;
  493.      MAC3 = F2I_FIX(M(_31)*IR1 + M(_32)*IR2 + M(_33)*IR3)+Cz;
  494.      FLAG = 0;
  495. }
  496.  
  497. static void mvmva_ir(REGS *r,MATRIX m)
  498. {
  499.      MAC1 = F2I_FIX(M(_11)*IR1 + M(_12)*IR2 + M(_13)*IR3);
  500.      MAC2 = F2I_FIX(M(_21)*IR1 + M(_22)*IR2 + M(_23)*IR3);
  501.      MAC3 = F2I_FIX(M(_31)*IR1 + M(_32)*IR2 + M(_33)*IR3);
  502.      FLAG = 0;
  503. }
  504.  
  505. static void mvmva_ir0(REGS *r,MATRIX m)
  506. {
  507.      MAC1 = F2I(M(_11)*IR1 + M(_12)*IR2 + M(_13)*IR3);
  508.      MAC2 = F2I(M(_21)*IR1 + M(_22)*IR2 + M(_23)*IR3);
  509.      MAC3 = F2I(M(_31)*IR1 + M(_32)*IR2 + M(_33)*IR3);
  510.      FLAG = 0;
  511. }
  512.  
  513. DEFFUNC(rtv0) { mvmva(r,&r->v0,r->rot); MAC2IR(); }
  514. DEFFUNC(rtv0_0) { mvmva0(r,&r->v0,r->rot); MAC2IR(); }
  515. DEFFUNC(rtv1) { mvmva(r,&r->v1,r->rot); MAC2IR(); }
  516. DEFFUNC(rtv2) { mvmva(r,&r->v2,r->rot); MAC2IR(); }
  517. DEFFUNC(rtir) { mvmva_ir(r,r->rot); MAC2IR(); }
  518. DEFFUNC(rtir0) { mvmva_ir0(r,r->rot); MAC2IR(); }
  519.  
  520. DEFFUNC(rtv0tr) { mvmva_cv(r,&r->v0,r->rot,&r->tr); MAC2IR(); }
  521. DEFFUNC(rtv1tr) { mvmva_cv(r,&r->v1,r->rot,&r->tr); MAC2IR(); }
  522. DEFFUNC(rtv2tr) { mvmva_cv(r,&r->v2,r->rot,&r->tr); MAC2IR(); }
  523. DEFFUNC(rtirtr) { mvmva_cv_ir(r,r->rot,&r->tr); MAC2IR(); }
  524.  
  525. DEFFUNC(rtv0bk) { mvmva_cv(r,&r->v0,r->rot,&r->bk); MAC2IR(); }
  526. DEFFUNC(rtv1bk) { mvmva_cv(r,&r->v1,r->rot,&r->bk); MAC2IR(); }
  527. DEFFUNC(rtv2bk) { mvmva_cv(r,&r->v2,r->rot,&r->bk); MAC2IR(); }
  528. DEFFUNC(rtirbk) { mvmva_cv_ir(r,r->rot,&r->bk); MAC2IR(); }
  529.  
  530. DEFFUNC(ll) { mvmva(r,&r->v0,r->light); MAC2IR1(); }
  531.  
  532. DEFFUNC(llv0) { mvmva(r,&r->v0,r->light); MAC2IR(); }
  533. DEFFUNC(llv1) { mvmva(r,&r->v1,r->light); MAC2IR(); }
  534. DEFFUNC(llv2) { mvmva(r,&r->v2,r->light); MAC2IR(); }
  535. DEFFUNC(llir) { mvmva_ir(r,r->light); MAC2IR(); }
  536.  
  537. DEFFUNC(llv0tr) { mvmva_cv(r,&r->v0,r->light,&r->tr); MAC2IR(); }
  538. DEFFUNC(llv1tr) { mvmva_cv(r,&r->v1,r->light,&r->tr); MAC2IR(); }
  539. DEFFUNC(llv2tr) { mvmva_cv(r,&r->v2,r->light,&r->tr); MAC2IR(); }
  540. DEFFUNC(llirtr) { mvmva_cv_ir(r,r->light,&r->tr); MAC2IR(); }
  541.  
  542. DEFFUNC(llv0bk) { mvmva_cv(r,&r->v0,r->light,&r->bk); MAC2IR(); }
  543. DEFFUNC(llv1bk) { mvmva_cv(r,&r->v1,r->light,&r->bk); MAC2IR(); }
  544. DEFFUNC(llv2bk) { mvmva_cv(r,&r->v2,r->light,&r->bk); MAC2IR(); }
  545. DEFFUNC(llirbk) { mvmva_cv_ir(r,r->light,&r->bk); MAC2IR(); }
  546.  
  547. DEFFUNC(lc) {}
  548.  
  549. DEFFUNC(lcv0) { mvmva(r,&r->v0,r->color); MAC2IR(); }
  550. DEFFUNC(lcv1) { mvmva(r,&r->v1,r->color); MAC2IR(); }
  551. DEFFUNC(lcv2) { mvmva(r,&r->v2,r->color); MAC2IR(); }
  552. DEFFUNC(lcir) { mvmva_ir(r,r->color); MAC2IR(); }
  553.  
  554. DEFFUNC(lcv0tr) { mvmva_cv(r,&r->v0,r->color,&r->tr); MAC2IR(); }
  555. DEFFUNC(lcv1tr) { mvmva_cv(r,&r->v1,r->color,&r->tr); MAC2IR(); }
  556. DEFFUNC(lcv2tr) { mvmva_cv(r,&r->v2,r->color,&r->tr); MAC2IR(); }
  557. DEFFUNC(lcirtr) { mvmva_cv_ir(r,r->color,&r->tr); MAC2IR(); }
  558.  
  559. DEFFUNC(lcv0bk) { mvmva_cv(r,&r->v0,r->color,&r->bk); MAC2IR(); }
  560. DEFFUNC(lcv1bk) { mvmva_cv(r,&r->v1,r->color,&r->bk); MAC2IR(); }
  561. DEFFUNC(lcv2bk) { mvmva_cv(r,&r->v2,r->color,&r->bk); MAC2IR(); }
  562. DEFFUNC(lcirbk) { mvmva_cv_ir(r,r->color,&r->bk); MAC2IR(); }
  563.  
  564.  
  565. DEFFUNC(DCPL)
  566. {
  567.      int tmp;
  568.  
  569.      tmp = (R*IR1)>>8;
  570.      MAC1 = tmp + FIX( IR0*Lm_B1(RFC-tmp) );
  571.      tmp = (G*IR2)>>8;
  572.      MAC2 = tmp + FIX( IR0*Lm_B2(GFC-tmp) );
  573.      tmp = (B*IR3)>>8;
  574.      MAC3 = tmp + FIX( IR0*Lm_B3(BFC-tmp) );
  575.      FLAG=0;
  576.      MAC2IR();
  577.      MAC2RGBx(4);
  578. }
  579.  
  580. DEFFUNC(DCPS)
  581. {
  582.         int tmp;
  583.  
  584.      tmp = R << 4;
  585.      MAC1 = tmp + FIX(IR0*Lm_B1(RFC-tmp));
  586.      tmp = G << 4;
  587.      MAC2 = tmp + FIX(IR0*Lm_B2(GFC-tmp));
  588.      tmp = B << 4;
  589.      MAC3 = tmp + FIX(IR0*Lm_B3(BFC-tmp));
  590.      FLAG = 0;
  591.      MAC2IR();
  592.      MAC2RGBx(4);
  593. }
  594.  
  595. DEFFUNC(INTPL)
  596. {
  597.      MAC1 = IR1 + IR0*Lm_B1(RFC-IR1);
  598.      MAC2 = IR2 + IR0*Lm_B2(GFC-IR2);
  599.      MAC3 = IR3 + IR0*Lm_B3(BFC-IR3);
  600.      FLAG = 0;
  601.      MAC2IR();
  602.      MAC2RGB();
  603. }
  604.  
  605. /* SQR */
  606. DEFFUNC(sqr0)
  607. {
  608.      MAC1 = IR1*IR1;
  609.      MAC2 = IR2*IR2;
  610.      MAC3 = IR3*IR3;
  611.      FLAG = 0;
  612.      MAC2IR1();
  613. }
  614.  
  615. DEFFUNC(sqr12)
  616. {
  617.      MAC1 = FIX(IR1*IR1);
  618.      MAC2 = FIX(IR2*IR2);
  619.      MAC3 = FIX(IR3*IR3);
  620.      FLAG = 0;
  621.      MAC2IR1();
  622. }
  623.  
  624. #define   _NCS(n) {\
  625.      double f,f1,f2,f3;                      \
  626.      f1 = f2 = f3 = 0;                       \
  627.      f = F_L11*F_VX##n + F_L12*F_VY##n + F_L13*F_VZ##n;     \
  628.      if (f > 0) {                            \
  629.           f1 += F_LR1*f;                     \
  630.           f2 += F_LG1*f;                     \
  631.           f3 += F_LB1*f;                     \
  632.      }                                  \
  633.      f = F_L21*F_VX##n + F_L22*F_VY##n + F_L23*F_VZ##n;     \
  634.      if (f > 0) {                            \
  635.           f1 += F_LR2*f;                     \
  636.           f2 += F_LG2*f;                     \
  637.           f3 += F_LB2*f;                     \
  638.      }                                  \
  639.      f = F_L31*F_VX##n + F_L32*F_VY##n + F_L33*F_VZ##n;     \
  640.      if (f > 0) {                            \
  641.           f1 += F_LR3*f;                     \
  642.           f2 += F_LG3*f;                     \
  643.           f3 += F_LB3*f;                     \
  644.      }                                  \
  645.      MAC1 = F2I(LOWLM(I2F(RBK) + F_FIX(f1)));          \
  646.      MAC2 = F2I(LOWLM(I2F(GBK) + F_FIX(f2)));          \
  647.      MAC3 = F2I(LOWLM(I2F(BBK) + F_FIX(f3)));          \
  648.      MAC2RGBx(15); }
  649.  
  650. #define   _NCDS(n) {                                   \
  651.      int tmp;                                \
  652.      double f,f1,f2,f3;                           \
  653.      f1 = f2 = f3 = 0;                            \
  654.      f = F_FIX(F_L11*F_VX##n + F_L12*F_VY##n + F_L13*F_VZ##n);   \
  655.      if (f > 0) {                                 \
  656.           f1 += F_LR1*f;                          \
  657.           f2 += F_LG1*f;                          \
  658.           f3 += F_LB1*f;                          \
  659.      }                                       \
  660.      f = F_FIX(F_L21*F_VX##n + F_L22*F_VY##n + F_L23*F_VZ##n);   \
  661.      if (f > 0) {                                 \
  662.           f1 += F_LR2*f;                          \
  663.           f2 += F_LG2*f;                          \
  664.           f3 += F_LB2*f;                          \
  665.      }                                       \
  666.      f = F_FIX(F_L31*F_VX##n + F_L32*F_VY##n + F_L33*F_VZ##n);   \
  667.      if (f > 0) {                                 \
  668.           f1 += F_LR3*f;                          \
  669.           f2 += F_LG3*f;                          \
  670.           f3 += F_LB3*f;                          \
  671.      }                                       \
  672.      tmp = F2I(CFIX(LOWLM(I2F(RBK) + F_FIX(f1))*I2F(R)));        \
  673.      MAC1 = tmp + (IR0*LOWLM(RFC-tmp));                \
  674.      tmp = F2I(CFIX(LOWLM(I2F(GBK) + F_FIX(f2))*I2F(G)));        \
  675.      MAC2 = tmp + (IR0*LOWLM(GFC-tmp));                \
  676.      tmp = F2I(CFIX(LOWLM(I2F(BBK) + F_FIX(f3))*I2F(B)));        \
  677.      MAC3 = tmp + (IR0*LOWLM(BFC-tmp));                \
  678.      MAC2RGBx(4); }
  679.  
  680. #define   _NCCS(n) { \
  681.      int t1,t2,t3,tt1,tt2,tt3; \
  682.      t1 = Lm1_B1(FIX(L11*VX##n + L12*VY##n + L13*VZ##n)); \
  683.      t2 = Lm1_B2(FIX(L21*VX##n + L22*VY##n + L23*VZ##n)); \
  684.      t3 = Lm1_B3(FIX(L31*VX##n + L32*VY##n + L33*VZ##n)); \
  685.      tt1 = Lm1_B1(RBK + FIX(LR1*t1 +LR2*t2 + LR3*t3)); \
  686.      tt2 = Lm1_B2(GBK + FIX(LG1*t1 +LG2*t2 + LG3*t3)); \
  687.      tt3 = Lm1_B3(BBK + FIX(LB1*t1 +LB2*t2 + LB3*t3)); \
  688.      MAC1 = FIX(R*tt1); \
  689.      MAC2 = FIX(G*tt2); \
  690.      MAC3 = FIX(B*tt3); \
  691.      MAC2RGBx(4); }
  692.  
  693. DEFFUNC(NCS)
  694. {
  695.      FLAG = 0;
  696.      _NCS(0);
  697.      MAC2IR1();
  698. }
  699.  
  700. DEFFUNC(NCT)
  701. {
  702.      /* NCS for V0,V1,V2 */
  703.      FLAG = 0;
  704.      _NCS(0);
  705.      _NCS(1);
  706.      _NCS(2);
  707.      MAC2IR1();
  708. }
  709.  
  710. DEFFUNC(NCDS)
  711. {
  712.      FLAG = 0;
  713.      _NCDS(0);
  714.      MAC2IR1();
  715. }
  716.  
  717. DEFFUNC(NCDT)
  718. {
  719.      /* NCDS for V0,V1,V2 */
  720.      FLAG = 0;
  721.      _NCDS(0);
  722.      _NCDS(1);
  723.      _NCDS(2);
  724.      MAC2IR1();
  725. }
  726.  
  727. DEFFUNC(DPCT)
  728. {
  729.      int tmp;
  730.  
  731.      tmp = R0 << 4;
  732.      MAC1 = tmp + IR0*Lm_B1(RFC-tmp);
  733.      tmp = G0 << 4;
  734.      MAC2 = tmp + IR0*Lm_B2(GFC-tmp);
  735.      tmp = B0 << 4;
  736.      MAC3 = tmp + IR0*Lm_B3(BFC-tmp);
  737.      FLAG = 0;
  738.      MAC2IR();
  739.      MAC2RGBx(4);
  740. }
  741.  
  742. DEFFUNC(NCCS)
  743. {
  744.      FLAG = 0;
  745.      _NCCS(0);
  746.      MAC2IR1();
  747. }
  748.  
  749. DEFFUNC(NCCT)
  750. {
  751.      /* NCCS for V0,V1,V2 */
  752.      FLAG = 0;
  753.      _NCCS(0);
  754.      _NCCS(1);
  755.      _NCCS(2);
  756.      MAC2IR1();
  757. }
  758.  
  759. DEFFUNC(CDP)
  760. {
  761.      int t1,t2,t3;
  762.      t1 = RBK + FIX(LR1*IR1 +LR2*IR2 + LR3*IR3);
  763.      t2 = GBK + FIX(LG1*IR1 +LG2*IR2 + LG3*IR3);
  764.      t3 = BBK + FIX(LB1*IR1 +LB2*IR2 + LB3*IR3);
  765.      MAC1 = R*t1 + IR0*Lm_B1(RFC-R*t1);
  766.      MAC2 = G*t2 + IR0*Lm_B2(GFC-G*t2);
  767.      MAC3 = B*t3 + IR0*Lm_B3(BFC-B*t3);
  768.      MAC2IR1();
  769.      MAC2RGB();
  770. }
  771.  
  772. DEFFUNC(CC)
  773. {
  774.      int t1,t2,t3;
  775.      t1 = RBK + FIX(LR1*IR1 +LR2*IR2 + LR3*IR3);
  776.      t2 = GBK + FIX(LG1*IR1 +LG2*IR2 + LG3*IR3);
  777.      t3 = BBK + FIX(LB1*IR1 +LB2*IR2 + LB3*IR3);
  778.      MAC1 = R*t1;
  779.      MAC2 = G*t2;
  780.      MAC3 = B*t3;
  781.      MAC2IR1();
  782.      MAC2RGB();
  783. }
  784.  
  785. DEFFUNC(NCLIP)
  786. {
  787.      /* SX0*SY1+SX1*SY2+SX2*SY0-SX0*SY2-SX1*SY0-SX2*SY1 */
  788.      FLAG = 0;
  789.      MAC0 = SX0*(SY1-SY2)+SX1*(SY2-SY0)+SX2*(SY0-SY1);
  790. }
  791.  
  792. DEFFUNC(AVSZ3)
  793. {
  794.      FLAG = 0;
  795.      MAC0 = FIX((SZ1 + SZ2 + SZ3)*ZSF3);
  796.      OTZ = Lm_D(MAC0);
  797. }
  798.  
  799. DEFFUNC(AVSZ4)
  800. {
  801.      FLAG = 0;
  802.      MAC0 = FIX((SZ0 + SZ1 + SZ2 + SZ3)*ZSF4);
  803.      OTZ = Lm_D(MAC0);
  804. }
  805.  
  806.  
  807. #define   D1   *(INT32*)&R11
  808. #define   D2   *(INT32*)&R22
  809. #define   D3   *(INT32*)&R33
  810.  
  811. /* OP */
  812. DEFFUNC(op0)
  813. {
  814.      MAC1 = D2*IR3 - D3*IR2;
  815.      MAC2 = D3*IR1 - D1*IR3;
  816.      MAC3 = D1*IR2 - D2*IR1;
  817.      MAC2IR();
  818. }
  819.  
  820. DEFFUNC(op12)
  821. {
  822.      MAC1 = FIX(D2*IR3 - D3*IR2);
  823.      MAC2 = FIX(D3*IR1 - D1*IR3);
  824.      MAC3 = FIX(D1*IR2 - D2*IR1);
  825.      MAC2IR();
  826. }
  827.  
  828. /* GPF */
  829. DEFFUNC(gpf0)
  830. {
  831.      FLAG = 0;
  832.      MAC1 = IR0*IR1;
  833.      MAC2 = IR0*IR2;
  834.      MAC3 = IR0*IR3;
  835.      MAC2IR();
  836.      MAC2RGB();
  837. }
  838.  
  839. DEFFUNC(gpf12)
  840. {
  841.      FLAG = 0;
  842.  
  843.      MAC1 = FIX(IR0*IR1);
  844.      MAC2 = FIX(IR0*IR2);
  845.      MAC3 = FIX(IR0*IR3);
  846.      MAC2IR();
  847.      MAC2RGB();
  848. }
  849.  
  850. DEFFUNC(gpl0)
  851. {
  852.      FLAG = 0;
  853.      MAC1 += IR0*IR1;
  854.      MAC2 += IR0*IR2;
  855.      MAC3 += IR0*IR3;
  856.      MAC2IR();
  857.      MAC2RGB();
  858. }
  859.  
  860. DEFFUNC(gpl12)
  861. {
  862.      FLAG = 0;
  863.  
  864.      MAC1 += FIX(IR0*IR1);
  865.      MAC2 += FIX(IR0*IR2);
  866.      MAC3 += FIX(IR0*IR3);
  867.      MAC2IR();
  868.      MAC2RGB();
  869. }
  870.  
  871.  
  872. typedef struct {
  873.      INT32     opcode;
  874.      void (*func)(REGS *r);
  875. } COP2TBL;
  876.  
  877. COP2TBL cop2tbl[] = {
  878.      {0x0180001,RTPS},
  879.      {0x0280030,RTPT},
  880. /*   {0x0400012,MVMVA}, */
  881.      {0x0680029,DCPL},
  882.      {0x0780010,DCPS},
  883.      {0x0980011,INTPL},
  884. /*   {0x0a00428,SQR}, */
  885.      {0x0c8041e,NCS},
  886.      {0x0d80420,NCT},
  887.      {0x0e80413,NCDS},
  888.      {0x0f80416,NCDT},
  889.      {0x0f8002a,DPCT},
  890.      {0x108041b,NCCS},
  891.      {0x118043f,NCCT},
  892.      {0x1280414,CDP},
  893.      {0x138041c,CC},
  894.      {0x1400006,NCLIP},
  895.      {0x158002d,AVSZ3},
  896.      {0x168002e,AVSZ4},
  897. /*   {0x170000c,OP},
  898.      {0x190003d,GPF},
  899.      {0x1a0003d,GPL}, */
  900.  
  901.      {0x0486012,rtv0},
  902.      {0x0406012,rtv0_0},
  903.      {0x048e012,rtv1},
  904.      {0x0496012,rtv2},
  905.      {0x049e012,rtir},
  906.      {0x041e012,rtir0},
  907.      {0x0480012,rtv0tr},
  908.      {0x0488012,rtv1tr},
  909.      {0x0490012,rtv2tr},
  910.      {0x0498012,rtirtr},
  911.      {0x0482012,rtv0bk},
  912.      {0x048a012,rtv1bk},
  913.      {0x0492012,rtv2bk},
  914.      {0x049a012,rtirbk},
  915.      {0x04a6412,ll},
  916.      {0x04a6012,llv0},
  917.      {0x04ae012,llv1},
  918.      {0x04b6012,llv2},
  919.      {0x04be012,llir},
  920.      {0x04a0012,llv0tr},
  921.      {0x04a8012,llv1tr},
  922.      {0x04b0012,llv2tr},
  923.      {0x04b8012,llirtr},
  924.      {0x04a2012,llv0bk},
  925.      {0x04aa012,llv1bk},
  926.      {0x04b2012,llv2bk},
  927.      {0x04ba012,llirbk},
  928.      {0x04da412,lc},
  929.      {0x04c6012,lcv0},
  930.      {0x04ce012,lcv1},
  931.      {0x04d6012,lcv2},
  932.      {0x04de012,lcir},
  933.      {0x04c0012,lcv0tr},
  934.      {0x04c8012,lcv1tr},
  935.      {0x04d0012,lcv2tr},
  936.      {0x04d8012,lcirtr},
  937.      {0x04c2012,lcv0bk},
  938.      {0x04ca012,lcv1bk},
  939.      {0x04d2012,lcv2bk},
  940.      {0x04da012,lcirbk},
  941.      {0x0a80428,sqr12},
  942.      {0x0a00428,sqr0},
  943.      {0x178000c,op12},
  944.      {0x170000c,op0},
  945.      {0x198003d,gpf12},
  946.      {0x190003d,gpf0},
  947.      {0x1a8003e,gpl12},
  948.      {0x1a0003e,gpl0},
  949.  
  950.      {0,NULL}
  951. };
  952.  
  953. cop2func cop2funcptr(int code)
  954. {
  955.      COP2TBL *tblp;
  956.      for(tblp=cop2tbl;tblp->opcode;tblp++) {
  957.           if (tblp->opcode==code) {
  958. // printf("Cop2 = %08x\n",code);
  959.                return (cop2func)tblp->func;
  960.           }
  961.      }
  962.      printf("unsupport cop2:%x\n",code);
  963.  
  964.      return NULL;
  965. }
  966.  
  967.  
  968. int cop2(int code,UINT32 *r)
  969. {
  970.      cop2func func = cop2funcptr(code);
  971.      if (func) { func(r); return 0;}
  972.      return -1;
  973. }
  974.  
  975. DEFFUNC(LZCR_read)
  976. {
  977.      int tmp = LZCS,cnt;
  978.      if (tmp&0x80000000) tmp=~tmp;
  979.      for(cnt=0;cnt<32 && (tmp&0x80000000)==0;cnt++,tmp<<=1);
  980.      LZCR = cnt;
  981. }
  982.  
  983. DEFFUNC(ORGB_read)
  984. {
  985.      ORGB = ((IR1 & 0xF80) >> 7) |
  986.                ((IR2 & 0xF80) >> 2) |
  987.                ((IR2 & 0xF80) << 3);
  988. }
  989.  
  990. DEFFUNC(IRGB_write)
  991. {
  992.      UINT32 data = IRGB;
  993.  
  994.      IR1_32 = (data&31)<<4;
  995.      IR2_32 = ((data>>5)&31)<<4;
  996.      IR3_32 = ((data>>10)&31)<<4;
  997. }
  998.  
  999. DEFFUNC(FLAG_read)
  1000. {
  1001.      if (FLAG&0x7fffffff) FLAG|=(1<<31); else FLAG&=(1<<31);
  1002. }
  1003.  
  1004. cop2func cop2readfuncptr(int regno)
  1005. {
  1006.      switch(regno) {
  1007.      case 29: return (cop2func)ORGB_read;
  1008.      case 31: return (cop2func)LZCR_read;
  1009.      case 31+32: return (cop2func)FLAG_read;
  1010.      }
  1011.      return NULL;
  1012. }
  1013.  
  1014. cop2func cop2writefuncptr(int regno)
  1015. {
  1016.      switch(regno) {
  1017.      case 28: return (cop2func)IRGB_write;
  1018.      }
  1019.      return NULL;
  1020. }
  1021.  
  1022. void cop2read(int regno,UINT32 *r)
  1023. {
  1024.      cop2func func=cop2readfuncptr(regno);
  1025.      if (func) func(r);
  1026. }
  1027.  
  1028. void cop2write(int regno,UINT32 *r)
  1029. {
  1030.      cop2func func=cop2writefuncptr(regno);
  1031.      if (func) func(r);
  1032. }